//! 协议层入口函数演示程序
//! 
//! 展示协议层如何直接接收NetworkStream并内部循环处理：
//! 1. 网络层创建具体的NetworkStream实现
//! 2. 网络层调用协议层入口函数，传入NetworkStream
//! 3. 协议层内部循环读取、解析、执行、响应

use std::io;
use redis_rs2::core::network::{NetworkStream, LightweightRuntime, ThreadPoolRuntime};
use redis_rs2::protocol::AbstractedProtocolHandler;
use redis_rs2::storage::SingleThreadCommandDispatcher;

/// 模拟TCP网络流实现
#[derive(Debug)]
struct MockTcpStream {
    remote_addr: String,
    connected: bool,
    /// 模拟从客户端收到的命令数据
    input_data: Vec<Vec<u8>>,
    /// 当前读取位置
    read_pos: usize,
    /// 发送给客户端的响应数据
    output_data: Vec<u8>,
}

impl MockTcpStream {
    fn new(remote_addr: String) -> Self {
        Self {
            remote_addr,
            connected: true,
            input_data: vec![
                // 模拟客户端发送的PING命令
                b"*1\r\n$4\r\nPING\r\n".to_vec(),
                // 模拟客户端发送的SET命令
                b"*3\r\n$3\r\nSET\r\n$3\r\nkey\r\n$5\r\nvalue\r\n".to_vec(),
                // 模拟客户端发送的GET命令
                b"*2\r\n$3\r\nGET\r\n$3\r\nkey\r\n".to_vec(),
            ],
            read_pos: 0,
            output_data: Vec::new(),
        }
    }
    
    /// 获取发送给客户端的响应（用于验证）
    pub fn get_responses(&self) -> &[u8] {
        &self.output_data
    }
}

impl NetworkStream for MockTcpStream {
    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
        if self.read_pos >= self.input_data.len() {
            // 没有更多数据，模拟连接关闭
            self.connected = false;
            return Ok(0);
        }
        
        let data = &self.input_data[self.read_pos];
        let to_copy = std::cmp::min(buf.len(), data.len());
        buf[..to_copy].copy_from_slice(&data[..to_copy]);
        
        self.read_pos += 1;
        println!("📥 Mock TCP收到数据: {} bytes", to_copy);
        
        Ok(to_copy)
    }
    
    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
        self.output_data.extend_from_slice(buf);
        println!("📤 Mock TCP发送响应: {} bytes", buf.len());
        println!("   响应内容: {}", String::from_utf8_lossy(buf));
        Ok(buf.len())
    }
    
    fn flush(&mut self) -> io::Result<()> {
        println!("🔄 Mock TCP刷新缓冲区");
        Ok(())
    }
    
    fn is_connected(&self) -> bool {
        self.connected
    }
    
    fn remote_addr(&self) -> Option<String> {
        Some(self.remote_addr.clone())
    }
    
    fn shutdown(&mut self) -> io::Result<()> {
        self.connected = false;
        println!("🔒 Mock TCP连接已关闭");
        Ok(())
    }
    
    fn network_type(&self) -> &'static str {
        "Mock-TCP"
    }
}

/// 模拟QUIC网络流实现
#[derive(Debug)]
struct MockQuicStream {
    remote_addr: String,
    connected: bool,
    commands_sent: usize,
}

impl MockQuicStream {
    fn new(remote_addr: String) -> Self {
        Self {
            remote_addr,
            connected: true,
            commands_sent: 0,
        }
    }
}

impl NetworkStream for MockQuicStream {
    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
        if self.commands_sent >= 2 {
            self.connected = false;
            return Ok(0);
        }
        
        // 模拟QUIC接收到不同的命令
        let data = match self.commands_sent {
            0 => b"*1\r\n$4\r\nPING\r\n",
            1 => b"*3\r\n$3\r\nSET\r\n$4\r\nquic\r\n$4\r\ntest\r\n",
            _ => return Ok(0),
        };
        
        let to_copy = std::cmp::min(buf.len(), data.len());
        buf[..to_copy].copy_from_slice(&data[..to_copy]);
        
        self.commands_sent += 1;
        println!("🚀 Mock QUIC收到数据: {} bytes", to_copy);
        
        Ok(to_copy)
    }
    
    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
        println!("📡 Mock QUIC发送响应: {} bytes", buf.len());
        println!("   响应内容: {}", String::from_utf8_lossy(buf));
        Ok(buf.len())
    }
    
    fn flush(&mut self) -> io::Result<()> {
        println!("⚡ Mock QUIC刷新缓冲区");
        Ok(())
    }
    
    fn is_connected(&self) -> bool {
        self.connected
    }
    
    fn remote_addr(&self) -> Option<String> {
        Some(self.remote_addr.clone())
    }
    
    fn shutdown(&mut self) -> io::Result<()> {
        self.connected = false;
        println!("🔐 Mock QUIC连接已关闭");
        Ok(())
    }
    
    fn network_type(&self) -> &'static str {
        "Mock-QUIC"
    }
}

/// 演示1：TCP + 线程池运行时
fn demo_tcp_protocol_entry() {
    println!("🚀 演示1: TCP网络流 + 协议层内部循环处理");
    
    // 1. 网络层创建具体的NetworkStream实现
    let tcp_stream = MockTcpStream::new("127.0.0.1:6379".to_string());
    let stream_box: Box<dyn NetworkStream> = Box::new(tcp_stream);
    
    // 2. 网络层创建运行时
    let runtime = ThreadPoolRuntime::new();
    
    // 3. 网络层创建协议处理器
    let mut protocol_handler = AbstractedProtocolHandler::new(1, runtime);
    
    // 4. 网络层创建存储分发器
    let mut storage_dispatcher = SingleThreadCommandDispatcher::new();
    
    // 5. 网络层调用协议层入口函数！
    // 这里就是关键：协议层接收NetworkStream并内部循环处理
    println!("📞 网络层调用协议层入口函数...");
    match protocol_handler.handle_connection_stream(stream_box, &mut storage_dispatcher) {
        Ok(()) => {
            println!("✅ 协议层处理完成");
        }
        Err(e) => {
            println!("❌ 协议层处理失败: {}", e);
        }
    }
    
    println!("  📊 演示1结果:");
    println!("    连接ID: {}", protocol_handler.connection_id());
    println!("    运行时类型: {}", protocol_handler.runtime_type());
    println!("    内存使用: {}字节", protocol_handler.memory_usage());
    println!("  ✅ TCP演示完成\n");
}

/// 演示2：QUIC + 线程池运行时
fn demo_quic_protocol_entry() {
    println!("🚀 演示2: QUIC网络流 + 协议层内部循环处理");
    
    // 1. 网络层创建QUIC网络流
    let quic_stream = MockQuicStream::new("127.0.0.1:443".to_string());
    let stream_box: Box<dyn NetworkStream> = Box::new(quic_stream);
    
    // 2. 网络层创建运行时
    let runtime = ThreadPoolRuntime::new();
    
    // 3. 网络层创建协议处理器
    let mut protocol_handler = AbstractedProtocolHandler::new(2, runtime);
    
    // 4. 网络层创建存储分发器
    let mut storage_dispatcher = SingleThreadCommandDispatcher::new();
    
    // 5. 网络层调用协议层入口函数
    println!("📞 网络层调用协议层入口函数...");
    match protocol_handler.handle_connection_stream(stream_box, &mut storage_dispatcher) {
        Ok(()) => {
            println!("✅ 协议层处理完成");
        }
        Err(e) => {
            println!("❌ 协议层处理失败: {}", e);
        }
    }
    
    println!("  📊 演示2结果:");
    println!("    连接ID: {}", protocol_handler.connection_id());
    println!("    运行时类型: {}", protocol_handler.runtime_type());
    println!("    内存使用: {}字节", protocol_handler.memory_usage());
    println!("  ✅ QUIC演示完成\n");
}

/// 演示3：架构分析
fn demo_architecture_analysis() {
    println!("🏗️ 演示3: 架构设计分析");
    
    println!("  🎯 关键设计特点:");
    println!("    1. ✅ 协议层入口函数: handle_connection_stream()");
    println!("    2. ✅ 参数: Box<dyn NetworkStream> - 网络层传入的抽象流");
    println!("    3. ✅ 协议层内部循环: while stream.is_connected()");
    println!("    4. ✅ 增量解析: feed_data() -> parse_value()");
    println!("    5. ✅ 立即响应: execute_command() -> stream.write()");
    
    println!("  📋 与之前设计的对比:");
    println!("    ❌ 旧设计: handle_data_sync(data: &[u8])");
    println!("       问题: 网络层需要loop，协议层只处理片段");
    println!("    ✅ 新设计: handle_connection_stream(stream: Box<dyn NetworkStream>)");
    println!("       优势: 协议层接管循环，完整控制流程");
    
    println!("  🔄 完整流程:");
    println!("    1. 网络层: 创建具体NetworkStream实现");
    println!("    2. 网络层: 调用protocol.handle_connection_stream(stream)");
    println!("    3. 协议层: while stream.is_connected() {{ ... }}");
    println!("    4. 协议层: stream.read() -> 读取数据");
    println!("    5. 协议层: parser.feed_data() -> 解析RESP");
    println!("    6. 协议层: execute_command() -> 执行命令");
    println!("    7. 协议层: stream.write() -> 写回响应");
    
    println!("  ✅ 架构分析完成\n");
}

/// 主函数
fn main() {
    println!("🎨 Redis-rs2 协议层入口函数演示程序");
    println!("================================================================");
    println!("展示协议层如何直接接收NetworkStream并内部循环处理\n");
    
    // 运行所有演示
    demo_tcp_protocol_entry();
    demo_quic_protocol_entry();
    demo_architecture_analysis();
    
    println!("🎉 总结:");
    println!("  协议层的入口函数设计完全符合你的需求：");
    println!("  ✅ 直接接收NetworkStream trait对象");
    println!("  ✅ 协议层内部进行循环读取和解析");
    println!("  ✅ 网络层只需创建具体实现并调用入口函数");
    println!("  ✅ 完美的抽象 - 协议层不知道具体网络实现");
    println!("  ✅ 高效的处理 - 避免了频繁的函数调用开销");
    println!("\n🚀 这就是正确的协议层入口函数设计！");
}